/*
Copyright (c) [2019年5月1日] [吴超]
[MBT_studio] is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
		 http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
See the Mulan PSL v2 for more details.
*/
#include "stdafx.h"

#include "ui快捷键编辑框.h"
#include "UI/intern/ui文本编辑.h"
#include "UI/intern/ui列表.h"
#include "UI/UI.h"

#include "ui矢量数据部件.h"




S_Props C_快捷键编辑框::m_Prop_按键名称_下拉列表;

static std::vector<S_MapPtrItem> g按键名称;

static std::map<int32, std::wstring> g键盘键值名称;
static std::map<int32, std::wstring> g鼠标键值名称;



void on_键盘控制键_Update(S_Props& prop) {
	
}

static void on_键盘键值编辑框布局(C_Widget* self, C_Widget** w, uint32 num) {
	float32 高度 = self->m_Size.y - self->m_间隔宽度 * 2;
	float32 宽度 = (self->m_Size.x - self->m_间隔宽度 * 2);
	vec2 大小 = { self->m_Size.x / 8, 高度 * 0.9f };

	w[0]->f_setPos({ float32(self->m_间隔宽度), float32(self->m_间隔宽度) });
	w[0]->f_setSize({ 宽度 * 0.7f - self->m_间隔宽度, 高度 });

	w[1]->f_setPos({ 宽度 * 0.7f + self->m_间隔宽度, 1 });
	w[1]->f_setSize({ 宽度 * 0.3f - self->m_间隔宽度, 高度 });

	//for (uint32 i = 0; i < 4; ++i) {
	//	w[i*2]->f_setPos({ float32(i * 大小.x), 0});
	//	w[i*2]->f_setSize(大小);
	//
	//	w[i * 2 + 1]->f_setPos({ float32(i * 大小.x*2), 0 });
	//	w[i * 2 + 1]->f_setSize(大小);
	//
	//
	//	w[8 + i * 2]->f_setPos({ float32(i * 大小.x), 高度 });
	//	w[8 + i * 2]->f_setSize(大小);
	//
	//	w[8 + i * 2 + 1]->f_setPos({ float32(i * 大小.x*2), 高度 });
	//	w[8 + i * 2 + 1]->f_setSize(大小);
	//}


}

C_键盘键值编辑框::C_键盘键值编辑框(S_UI创建环境& ctx) {
	mf_布局Fun = on_键盘键值编辑框布局;


	m_控制键 = f_alloc_EnumProp(nullptr, {
			{L"Ctrl", ""},
			{L"Shift", ""},
			{L"Alt", ""},
			//{L"Cmd", ""},
							  }, L"操作类型", 0, on_键盘控制键_Update);

	C_枚举表* 控制键组件 = new C_枚举表(ctx, m_控制键, false, E_方向::e_横向);
	C_Widget* 键值组件 = f_ui_创建行文本编辑框(ctx);


	f_添加子组件(控制键组件);
	f_添加子组件(键值组件);
}

C_键盘键值编辑框::~C_键盘键值编辑框() {
	
}







static void on_快捷键编辑框Draw(C_Widget* self, S_2D画布* 画布) {
	C_快捷键编辑框* box = static_cast<C_快捷键编辑框*>(self);
	box->m_背景绘制.m_属性 = f_vg_gen属性(画布);

	S_凸边图元 图元 = {};
	图元.属性 = f_vg_get属性指针(画布, box->m_背景绘制.m_属性);
	box->m_背景绘制.f_Draw(画布, 图元, E_笔刷类型::e_单色填充);

	auto 字体 = f_surface_get字体(*self->m_UIctx, S_UI主题::ui_默认字体);
	box->m_字符绘制.f_Draw(画布, &字体, box->m_背景绘制.m_属性);
}

static void on_快捷键编辑框布局(C_Widget* self, C_Widget** w, uint32 num) {
	float32 高度 = self->m_Size.y * 0.5;
	vec2 大小 = { self->m_Size.x / 8, 高度 * 0.9f};

	f_Layout_网格(w, num, 4, 2, {1, 20}, self->m_Size - vec2{2,20});
	
}

static void on_快捷键编辑框变换修改(C_Widget* self) {
	C_快捷键编辑框* box = static_cast<C_快捷键编辑框*>(self);

	mat3X2 Mat;
	Mat.row0 = box->m_Pos;
	Mat.row1 = box->m_Size;
	Mat.row2 = { S_UI主题::ui_面板圆角半径*2, 0 };

	box->m_背景绘制.f_alloc(1);
	box->m_背景绘制.f_set单色填充(0, Mat, self->m_颜色A, self->m_图元);

	Mat.row0.x += 30;
	Mat.row1.y = 18;
	box->m_字符绘制.f_alloc(2, 32);
	box->m_字符绘制.f_绘制文本({ Mat.row0 , Mat.row1 }, S_UI主题::uic_文字颜色, 0, box->m_Value.m_Name, E_对齐方式::e_左对齐);
	Mat.row0.x += 100;
	box->m_字符绘制.f_绘制文本({ Mat.row0 , Mat.row1 }, {120,120,120,255}, 1, box->m_标签文本, E_对齐方式::e_左对齐);

}





void on_鼠标按键0_Update(S_Props& prop) {

}

void on_鼠标按键1_Update(S_Props& prop) {

}

void on_鼠标按键2_Update(S_Props& prop) {

}

void on_鼠标按键3_Update(S_Props& prop) {

}


void on_鼠标按键状态0_Update(S_Props& prop) {

}

void on_鼠标按键状态1_Update(S_Props& prop) {

}

void on_鼠标按键状态2_Update(S_Props& prop) {

}

void on_鼠标按键状态3_Update(S_Props& prop) {

}




void on_键盘按键0_Update(S_Props& prop, S_MapPtr& ptrItem, int32 操作类型) {
	
}

void on_键盘按键1_Update(S_Props& prop, S_MapPtr& ptrItem, int32 操作类型) {

}

void on_键盘按键2_Update(S_Props& prop, S_MapPtr& ptrItem, int32 操作类型) {

}

void on_键盘按键3_Update(S_Props& prop, S_MapPtr& ptrItem, int32 操作类型) {
	
}


void on_键盘按键状态0_Update(S_Props& prop) {

}

void on_键盘按键状态1_Update(S_Props& prop) {

}

void on_键盘按键状态2_Update(S_Props& prop) {

}

void on_键盘按键状态3_Update(S_Props& prop) {

}



C_快捷键编辑框::C_快捷键编辑框(S_UI创建环境& ctx) : C_Widget(&ctx) {
	if (g按键名称.empty()) {
		for (uint32 i = 50; i < 128; ++i) {
			std::wstring t = L"";
			t = wchar_t(i);
			g按键名称.push_back({ (void*)i, t, ""});
		}

		m_Prop_按键名称_下拉列表 = f_alloc_StrIndexProp(g按键名称, L"按键名称");


		
		g键盘键值名称[S_InputKey::e_KEY_左SHIFT] = L"左Shift";
		g键盘键值名称[S_InputKey::e_KEY_左CTRL] = L"左Ctrl";
		g键盘键值名称[S_InputKey::e_KEY_左ALT] = L"左Alt";

		g键盘键值名称[S_InputKey::e_KEY_A] = L"A";
		g键盘键值名称[S_InputKey::e_KEY_B] = L"B";
		g键盘键值名称[S_InputKey::e_KEY_C] = L"C";
		g键盘键值名称[S_InputKey::e_KEY_D] = L"D";
		g键盘键值名称[S_InputKey::e_KEY_E] = L"E";
		g键盘键值名称[S_InputKey::e_KEY_F] = L"F";
		g键盘键值名称[S_InputKey::e_KEY_G] = L"G";
		g键盘键值名称[S_InputKey::e_KEY_H] = L"H";
		g键盘键值名称[S_InputKey::e_KEY_I] = L"I";
		g键盘键值名称[S_InputKey::e_KEY_J] = L"J";
		g键盘键值名称[S_InputKey::e_KEY_K] = L"K";
		g键盘键值名称[S_InputKey::e_KEY_L] = L"L";
		g键盘键值名称[S_InputKey::e_KEY_M] = L"M";
		g键盘键值名称[S_InputKey::e_KEY_N] = L"N";
		g键盘键值名称[S_InputKey::e_KEY_O] = L"O";
		g键盘键值名称[S_InputKey::e_KEY_P] = L"P";
		g键盘键值名称[S_InputKey::e_KEY_Q] = L"Q";
		g键盘键值名称[S_InputKey::e_KEY_R] = L"R";
		g键盘键值名称[S_InputKey::e_KEY_S] = L"S";
		g键盘键值名称[S_InputKey::e_KEY_T] = L"T";
		g键盘键值名称[S_InputKey::e_KEY_U] = L"U";
		g键盘键值名称[S_InputKey::e_KEY_V] = L"V";
		g键盘键值名称[S_InputKey::e_KEY_W] = L"W";
		g键盘键值名称[S_InputKey::e_KEY_X] = L"X";
		g键盘键值名称[S_InputKey::e_KEY_Y] = L"Y";
		g键盘键值名称[S_InputKey::e_KEY_Z] = L"Z";
		g键盘键值名称[S_InputKey::e_KEY_0] = L"0";
		g键盘键值名称[S_InputKey::e_KEY_1] = L"1";
		g键盘键值名称[S_InputKey::e_KEY_2] = L"2";
		g键盘键值名称[S_InputKey::e_KEY_3] = L"3";
		g键盘键值名称[S_InputKey::e_KEY_4] = L"4";
		g键盘键值名称[S_InputKey::e_KEY_5] = L"5";
		g键盘键值名称[S_InputKey::e_KEY_6] = L"6";
		g键盘键值名称[S_InputKey::e_KEY_7] = L"7";
		g键盘键值名称[S_InputKey::e_KEY_8] = L"8";
		g键盘键值名称[S_InputKey::e_KEY_9] = L"9";



		g鼠标键值名称[E_Input_鼠标按键::e_左键] = L"鼠标左键";
		g鼠标键值名称[E_Input_鼠标按键::e_右键] = L"鼠标左键";
		g鼠标键值名称[E_Input_鼠标按键::e_中键] = L"鼠标左键";
		g鼠标键值名称[E_Input_鼠标按键::e_滚轮] = L"鼠标滚轮";
		g鼠标键值名称[E_Input_鼠标按键::e_X轴] = L"鼠标X轴";
		g鼠标键值名称[E_Input_鼠标按键::e_Y轴] = L"鼠标Y轴";
	}

	m_操作类型 = f_alloc_EnumProp(nullptr, {
			{L"键盘按键", ""},
			{L"鼠标按键", ""},
			{L"拖拽", ""},
			{L"鼠标双击", ""},
	}, L"操作类型", 0, on_鼠标按键0_Update);


	std::vector<S_标题和图标> 标题图标 = {
		{L"鼠标左键", ""},
		{L"鼠标中键", ""},
		{L"鼠标右键", ""},
		{L"鼠标键1", ""},
	};
	m_鼠标按键0 = f_alloc_EnumProp(nullptr, 标题图标, L"鼠标按键0", 0, on_鼠标按键0_Update);

	m_鼠标按键1 = f_alloc_EnumProp(nullptr, 标题图标, L"鼠标按键1", 0, on_鼠标按键1_Update);

	m_鼠标按键2 = f_alloc_EnumProp(nullptr, 标题图标, L"鼠标按键2", 0, on_鼠标按键2_Update);

	m_鼠标按键3 = f_alloc_EnumProp(nullptr, 标题图标, L"鼠标按键3", 0, on_鼠标按键3_Update);


	std::vector<S_标题和图标> 状态标题图标 = {
		{L"准备", ""},
		{L"按下", ""},
		{L"按下中", ""},
		{L"放开", ""},
	};
	m_鼠标按键状态0 = f_alloc_EnumProp(nullptr, 状态标题图标, L"鼠标按键状态0", 0, on_鼠标按键状态0_Update);

	m_鼠标按键状态1 = f_alloc_EnumProp(nullptr, 状态标题图标, L"鼠标按键状态1", 0, on_鼠标按键状态1_Update);

	m_鼠标按键状态2 = f_alloc_EnumProp(nullptr, 状态标题图标, L"鼠标按键状态2", 0, on_鼠标按键状态2_Update);

	m_鼠标按键状态3 = f_alloc_EnumProp(nullptr, 状态标题图标, L"鼠标按键状态3", 0, on_鼠标按键状态3_Update);




	//std::vector<S_标题和图标> 键盘按键标题图标;
	//for (uint8 i = 0; i < 128; ++i) {
	//	std::wstring t = L"";
	//	t = wchar_t(i);
	//	键盘按键标题图标.push_back({t, ""});
	//}
	//m_键盘按键0 = f_alloc_EnumProp(nullptr, 键盘按键标题图标, L"键盘按键0", 0, on_键盘按键0_Update);
	//m_键盘按键1 = f_alloc_EnumProp(nullptr, 键盘按键标题图标, L"键盘按键1", 0, on_键盘按键1_Update);
	//m_键盘按键2 = f_alloc_EnumProp(nullptr, 键盘按键标题图标, L"键盘按键2", 0, on_键盘按键2_Update);
	//m_键盘按键3 = f_alloc_EnumProp(nullptr, 键盘按键标题图标, L"键盘按键3", 0, on_键盘按键3_Update);
	//m_键盘按键0 = f_alloc_LineStrProp(nullptr, L"键盘按键0", on_键盘按键0_Update);
	//m_键盘按键1 = f_alloc_LineStrProp(nullptr, L"键盘按键1", on_键盘按键1_Update);
	//m_键盘按键2 = f_alloc_LineStrProp(nullptr, L"键盘按键2", on_键盘按键2_Update);
	//m_键盘按键3 = f_alloc_LineStrProp(nullptr, L"键盘按键3", on_键盘按键3_Update);

	m_键盘按键状态0 = f_alloc_EnumProp(nullptr, 状态标题图标, L"键盘按键状态0", 0, on_键盘按键状态0_Update);
	m_键盘按键状态1 = f_alloc_EnumProp(nullptr, 状态标题图标, L"键盘按键状态1", 0, on_键盘按键状态1_Update);
	m_键盘按键状态2 = f_alloc_EnumProp(nullptr, 状态标题图标, L"键盘按键状态2", 0, on_键盘按键状态2_Update);
	m_键盘按键状态3 = f_alloc_EnumProp(nullptr, 状态标题图标, L"键盘按键状态3", 0, on_键盘按键状态3_Update);



	C_枚举表* 鼠标按键0 = new C_枚举表(ctx, m_鼠标按键0, false, E_方向::e_横向);
	C_枚举表* 鼠标按键1 = new C_枚举表(ctx, m_鼠标按键1, false, E_方向::e_横向);
	C_枚举表* 鼠标按键2 = new C_枚举表(ctx, m_鼠标按键2, false, E_方向::e_横向);
	C_枚举表* 鼠标按键3 = new C_枚举表(ctx, m_鼠标按键3, false, E_方向::e_横向);

	C_枚举表* 鼠标按键状态0 = new C_枚举表(ctx, m_鼠标按键状态0, false, E_方向::e_横向);
	C_枚举表* 鼠标按键状态1 = new C_枚举表(ctx, m_鼠标按键状态1, false, E_方向::e_横向);
	C_枚举表* 鼠标按键状态2 = new C_枚举表(ctx, m_鼠标按键状态2, false, E_方向::e_横向);
	C_枚举表* 鼠标按键状态3 = new C_枚举表(ctx, m_鼠标按键状态3, false, E_方向::e_横向);

	f_添加子组件(鼠标按键0);
	f_添加子组件(鼠标按键状态0);
	f_添加子组件(鼠标按键1);
	f_添加子组件(鼠标按键状态1);
	f_添加子组件(鼠标按键2);
	f_添加子组件(鼠标按键状态2);
	f_添加子组件(鼠标按键3);
	f_添加子组件(鼠标按键状态3);



	C_键盘键值编辑框* 键盘按键0 = new C_键盘键值编辑框(ctx);
	C_键盘键值编辑框* 键盘按键1 = new C_键盘键值编辑框(ctx);
	C_键盘键值编辑框* 键盘按键2 = new C_键盘键值编辑框(ctx);
	C_键盘键值编辑框* 键盘按键3 = new C_键盘键值编辑框(ctx);
	//m_Prop_按键名称_下拉列表->mf_变换修改 = on_键盘按键0_Update;
	
	C_枚举表* 键盘按键状态0 = new C_枚举表(ctx, m_键盘按键状态0, false, E_方向::e_横向);
	C_枚举表* 键盘按键状态1 = new C_枚举表(ctx, m_键盘按键状态1, false, E_方向::e_横向);
	C_枚举表* 键盘按键状态2 = new C_枚举表(ctx, m_键盘按键状态2, false, E_方向::e_横向);
	C_枚举表* 键盘按键状态3 = new C_枚举表(ctx, m_键盘按键状态3, false, E_方向::e_横向);



	//f_添加子组件(键盘按键0);
	//f_添加子组件(键盘按键状态0);
	//
	//f_添加子组件(键盘按键1);
	//f_添加子组件(键盘按键状态1);
	//
	//f_添加子组件(键盘按键2);
	//f_添加子组件(键盘按键状态2);
	//
	//f_添加子组件(键盘按键3);
	//f_添加子组件(键盘按键状态3);


	mf_DrawFun = on_快捷键编辑框Draw;
	mf_布局Fun = on_快捷键编辑框布局;
	mf_变换修改 = on_快捷键编辑框变换修改;

	m_颜色A = S_UI主题::uic_深灰;
	m_图元 = S_Widget预设图元::m_圆角矩形;
}

C_快捷键编辑框::~C_快捷键编辑框() {
	
}


C_Widget* f_ui_创建快捷键编辑框(S_UI创建环境& ctx) {
	C_快捷键编辑框* box = new C_快捷键编辑框(ctx);
	box->f_setSize({ 40,100 });

	return box;
}

void f_ui_快捷键编辑框绑定属性(C_Widget* self, S_Props& prop) {
	C_快捷键编辑框* box = dynamic_cast<C_快捷键编辑框*>(self);
	box->m_Value = prop;
	box->m_标签文本 = L"";


	S_键位映射* key = f_prop_键位(prop);
	switch (key->m_Type) {
		case E_键位映射类型::e_键映射类型_键盘: {
			S_键盘键位映射* km = (S_键盘键位映射*)key;
			for (uint8 i = 0; i < 4; ++i) {
				auto 键值 = g键盘键值名称[km->键盘按键[i]];
				if (键值.empty() == false) {
					box->m_标签文本 += 键值 + L" +";
				}
				
			}
			break;
		}
		case E_键位映射类型::e_键映射类型_鼠标: {
			S_鼠标键位映射* km = (S_鼠标键位映射*)key;
			for (uint8 i = 0; i < 4; ++i) {
				auto 键值 = g键盘键值名称[km->键盘按键[i]];
				if (键值.empty() == false) {
					box->m_标签文本 += 键值 + L" +";
				}

			}
			for (uint8 i = 0; i < 4; ++i) {
				if (km->鼠标按键[i]) {
					auto 键值 = g鼠标键值名称[km->鼠标按键[i]];
					box->m_标签文本 += 键值 + L" +";
				}
			}
			break;
		}
		case E_键位映射类型::e_键映射类型_拖拽: {
			S_拖拽键位映射* km = (S_拖拽键位映射*)key;
			for (uint8 i = 0; i < 4; ++i) {
				auto 键值 = g键盘键值名称[km->键盘按键[i]];
				if (键值.empty() == false) {
					box->m_标签文本 += 键值 + L" +";
				}

			}
			for (uint8 i = 0; i < 4; ++i) {
				if (km->鼠标按键[i]) {
					auto 键值 = g鼠标键值名称[km->鼠标按键[i]];
					box->m_标签文本 += 键值 + L" +";
				}

			}
			break;
		}
		case E_键位映射类型::e_键映射类型_双击: {
			S_鼠标双击键位映射* km = (S_鼠标双击键位映射*)key;
			for (uint8 i = 0; i < 4; ++i) {
				auto 键值 = g键盘键值名称[km->键盘按键[i]];
				if (键值.empty() == false) {
					box->m_标签文本 += 键值 + L" +";
				}

			}
			for (uint8 i = 0; i < 4; ++i) {
				if (km->鼠标按键[i]) {
					auto 键值 = g鼠标键值名称[km->鼠标按键[i]];
					box->m_标签文本 += 键值 + L" +";
				}

			}
			break;
		}
	}

	if (box->m_标签文本.empty() == false) {
		box->m_标签文本.pop_back();
	}

	f_prop_enum(box->m_鼠标按键0);
}
